// using System;
// using System.Collections.Generic;
// using Unity.Collections;
// using UnityEngine;

// public class MyPriorityQueue<T> where T : struct{
// 	// 使用NativeList来存储堆元素
// 	private NativeList<T> heap;
// 	// 自定义比较函数，用于比较两个元素的大小
// 	private Comparison<T> compareFunction;

// 	// 构造函数，初始化堆和比较函数
// 	public MyPriorityQueue(Comparison<T> compareFunction) {
// 		this.heap = new NativeList<T>(Allocator.Persistent);
// 		this.compareFunction = compareFunction;
// 	}

// 	// 入堆操作
// 	public void Enqueue(T item) {
// 		// 将新元素添加到堆的末尾
// 		heap.Add(item);
// 		// 从下往上调整堆，确保堆的性质
// 		int childIndex = heap.Length - 1;
// 		while (childIndex > 0) {
// 			int parentIndex = (childIndex - 1) / 2;
// 			// 如果子节点比父节点小，交换它们
// 			if (compareFunction(heap[childIndex], heap[parentIndex]) < 0) {
// 				// NativeSwap(ref heap[childIndex], ref heap[parentIndex]);
// 				NativeSwap(heap[childIndex], heap[parentIndex]);
// 			}
// 			// 如果子节点不比父节点小，停止调整
// 			else {
// 				break;
// 			}
// 			childIndex = parentIndex;
// 		}
// 	}

// 	// 取堆顶元素
// 	public T Peek() {
// 		// 如果堆为空，抛出异常
// 		if (heap.Length == 0) {
// 			throw new InvalidOperationException("The priority queue is empty.");
// 		}
// 		// 返回堆顶元素，即最小元素
// 		return heap[0];
// 	}

// 	// 出堆操作
// 	public T Dequeue() {
// 		// 如果堆为空，抛出异常
// 		if (heap.Length == 0) {
// 			throw new InvalidOperationException("The priority queue is empty.");
// 		}

// 		// 将堆顶元素与最后一个元素交换，然后移除最后一个元素
// 		T item = heap[0];
// 		heap[0] = heap[heap.Length - 1];
// 		heap.RemoveAt(heap.Length - 1);
// 		// 从上往下调整堆，确保堆的性质
// 		int parentIndex = 0;
// 		while (true) {
// 			int leftChildIndex = 2 * parentIndex + 1;
// 			int rightChildIndex = 2 * parentIndex + 2;
// 			// 如果左子节点的索引超出了堆的范围，停止调整
// 			if (leftChildIndex >= heap.Length) break;

// 			// 找到两个子节点中较小的一个
// 			int first = leftChildIndex;
// 			if (rightChildIndex < heap.Length && compareFunction(heap[rightChildIndex], heap[first]) < 0) {
// 				first = rightChildIndex;
// 			}

// 			// 如果父节点比较小的子节点大，交换它们
// 			if (compareFunction(heap[parentIndex], heap[first]) > 0) {
// 				NativeSwap(heap[parentIndex], heap[first]);
// 				parentIndex = first;
// 			}
// 			// 如果父节点不比子节点大，停止调整
// 			else {
// 				break;
// 			}
// 		}

// 		// 返回被移除的堆顶元素
// 		return item;
// 	}

// 	// 辅助函数，用于交换两个元素
// 	private void NativeSwap(T lhs, T rhs) {
// 		T temp = lhs;
// 		lhs = rhs;
// 		rhs = temp;
// 	}

// 	// 析构函数，用于释放资源
// 	~MyPriorityQueue() {
// 		heap.Dispose();
// 	}
// }

// // // 使用示例
// // public class ExampleUsage : MonoBehaviour {
// // 	void Start() {
// // 		// 创建一个优先队列，使用自定义的比较函数
// // 		PriorityQueue<int> priorityQueue = new PriorityQueue<int>((x, y) => x.CompareTo(y));

// // 		// 入堆操作
// // 		priorityQueue.Enqueue(10);
// // 		priorityQueue.Enqueue(5);
// // 		priorityQueue.Enqueue(20);

// // 		// 取堆顶元素
// // 		Debug.Log("Peek: " + priorityQueue.Peek()); // 应该输出5，因为它是最小的

// // 		// 出堆操作
// // 		Debug.Log("Dequeue: " + priorityQueue.Dequeue()); // 应该输出5，然后堆顶变为10
// // 	}
// // }